home *** CD-ROM | disk | FTP | other *** search
/ CICA 1995 September (Japanese) / CICA Shareware for Windows CD-ROM (Walnut Creek) (September 1995) (Japanese) (Disc 2).iso / disc2 / patches / symantec / rtlinc.exe / COMPLEX.H < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-19  |  10.6 KB  |  434 lines
  1. /*ident    "@(#)complex.h    1.3   6/2/90" */
  2.  
  3. #ifndef __COMPLEX_H
  4. #define __COMPLEX_H    1
  5.  
  6. /*
  7. **  (c) Copyright 1988-1990 by Dyad Software Corp.
  8. **  All Rights Reserved
  9. **
  10. **  Authors: lwd, geb
  11. */
  12.  
  13. #ifndef __MATH_H
  14. #include <math.h>
  15. #endif
  16.  
  17. #ifndef __FLTPNT_H
  18. #include <fltpnt.h>
  19. #endif
  20.  
  21. class ostream;
  22. class istream;
  23.  
  24.  
  25. class complex
  26. {
  27.  
  28.  public:
  29.    friend double real ( const complex& );     
  30.    friend double imag ( const complex& );     
  31.  
  32.    friend complex cos ( const complex& );
  33.    friend complex cosh ( const complex& );
  34.    friend complex sin ( const complex& );
  35.    friend complex sinh ( const complex& );
  36.    friend complex tan ( const complex& );
  37.    friend complex tanh ( const complex& );
  38.    friend complex log ( const complex& );
  39.    friend complex log10 ( const complex& );
  40.    friend complex sqrt ( const complex& );
  41.    friend double abs ( const complex& );
  42.    friend complex conj ( const complex& );
  43.    friend double norm ( const complex& );
  44.    friend double modulus ( const complex& );
  45.    friend double arg ( const complex& );
  46.    friend complex asin ( const complex& );
  47.    friend complex acos ( const complex& );
  48.    friend complex atan ( const complex& );
  49.    friend complex asinh ( const complex& );
  50.    friend complex atanh ( const complex& );
  51.    friend complex exp ( const complex& );
  52.    friend complex polar ( double r, double theta = 0);
  53.  
  54.    friend complex operator + ( const complex&, const complex& );
  55.    friend complex operator + ( double, const complex& );
  56.    friend complex operator + ( const complex&, double );
  57.  
  58.    friend complex operator - ( const complex&, const complex& );
  59.    friend complex operator - ( double, const complex& );
  60.    friend complex operator - ( const complex&, double );
  61.  
  62.    friend complex operator * ( const complex&, const complex& );
  63.    friend complex operator * ( double, const complex& );
  64.    friend complex operator * ( const complex&, double );
  65.  
  66.    friend complex operator / ( const complex&, const complex& );
  67.    friend complex operator / ( double, const complex& );
  68.    friend complex operator / ( const complex&, double );
  69.  
  70.    friend complex pow( const complex& lhs, double rhs );
  71.    friend complex pow( const complex& lhs, const complex & rhs );
  72.    friend complex pow( double lhs, const complex & rhs);
  73.    friend complex pow( const complex& lhs, int rhs);
  74.  
  75.    friend int operator && ( const complex&, const complex& );
  76.    friend int operator && ( double, const complex& );
  77.    friend int operator && ( const complex&, double );
  78.  
  79.    friend int operator || ( const complex&, const complex& );
  80.    friend int operator || ( double, const complex& );
  81.    friend int operator || ( const complex&, double );
  82.  
  83.    friend int operator != ( const complex&, const complex& );
  84.    friend int operator != ( double, const complex& );
  85.    friend int operator != ( const complex&, double );
  86.  
  87.    friend int operator == ( const complex&, const complex& );
  88.    friend int operator == ( double, const complex& );
  89.    friend int operator == ( const complex&, double );
  90.  
  91.    friend ostream& operator << ( ostream& s, const complex& x);
  92.    friend istream& operator >> ( istream& s, complex& x);
  93.  
  94.  public:
  95.  
  96.    complex ( );
  97.    complex ( double r, double i ); /*   this is not declared (double r, double i = 0)
  98.                                         to avoid implicit conversion. Binary operations
  99.                                         are explicitly declared thus avoiding potential 
  100.                                         ambiguities. */
  101.    complex ( const complex & );   
  102.    double& real ( );
  103.    double& imag ( );
  104.    
  105.    complex& operator = ( const complex& );
  106.    complex& operator = ( double );
  107.    
  108.    complex& operator += ( const complex& );
  109.    complex& operator += ( double );
  110.    
  111.    complex& operator -= ( const complex& );
  112.    complex& operator -= ( double );
  113.    
  114.    complex& operator *= ( const complex& );
  115.    complex& operator *= ( double );
  116.    
  117.    complex& operator /= ( const complex& );
  118.    complex& operator /= ( double );
  119.    
  120.    int operator ! () const;
  121.    complex operator - () const;
  122.    
  123.  private:
  124.    double re;
  125.    double im;
  126.  };
  127.  
  128. inline complex::complex ( )
  129. { 
  130.     re = im = NAN;
  131. }
  132.  
  133. inline complex::complex ( double r, double i ): re(r), im(i) {}
  134.      inline complex::complex( const complex& z)
  135. {
  136.   re = z.re;
  137.   im = z.im;
  138. }    
  139.  
  140. inline double real ( const complex& z){ return z.re; }     
  141. inline double imag ( const complex& z){ return z.im; }
  142.      
  143. inline double& complex::real (){ return re; }     
  144. inline double& complex::imag (){ return im; }
  145.      
  146. /* operator + */
  147. inline complex operator + ( const complex& lhs, const complex& rhs )
  148. {
  149.   return  complex ( lhs.re + rhs.re, lhs.im + rhs.im );
  150. }
  151. inline complex operator + ( double  lhs, const complex& rhs )
  152. {
  153.   return  complex ( lhs + rhs.re, rhs.im );
  154. }
  155. inline complex operator + ( const complex& lhs, double rhs )
  156. {
  157.   return  complex ( lhs.re + rhs, lhs.im );
  158. }
  159.  
  160. /* operator - */
  161. inline complex operator - ( const complex& lhs, const complex& rhs )
  162. {
  163.   return  complex ( lhs.re - rhs.re, lhs.im - rhs.im );
  164. }
  165. inline complex operator - ( double lhs, const complex& rhs )
  166. {
  167.   return  complex ( lhs - rhs.re, - rhs.im );
  168. }
  169. inline complex operator - ( const complex& lhs, double rhs )
  170. {
  171.   return  complex ( lhs.re - rhs, lhs.im );
  172. }
  173.  
  174. /* operator * */
  175. inline complex operator * ( const complex& lhs, const complex& rhs )
  176. {
  177.   return  complex ( lhs.re * rhs.re - lhs.im * rhs.im, 
  178.            lhs.re * rhs.im + lhs.im*rhs.re );
  179. }
  180. inline complex operator * ( double lhs, const complex& rhs )
  181. {
  182.   return  complex ( lhs * rhs.re, lhs * rhs.im );
  183. }
  184. inline complex operator * ( const complex& lhs, double rhs )
  185. {
  186.   return  complex ( lhs.re * rhs, lhs.im*rhs );
  187. }
  188.  
  189. /* operator / */
  190.  
  191. inline complex operator / ( const complex& lhs, double rhs )
  192. {
  193.   return complex( lhs.re / rhs, lhs.im /rhs );
  194. }
  195.  
  196. /* unary operators */
  197. inline complex complex::operator - ( ) const
  198. {
  199.   return  complex ( -re, -im );
  200. }
  201.  
  202. inline int complex::operator ! ( )  const
  203. {
  204.   return  ( re == 0 ) && ( im == 0 ) ;
  205. }    
  206.  
  207.  
  208. inline complex & complex::operator = ( const complex& z)
  209. {
  210.   re = z.re;
  211.   im = z.im;
  212.   return  *this;
  213. }    
  214.  
  215. inline complex & complex::operator = ( double x)
  216. {
  217.   re = x;
  218.   im = 0;
  219.   return  *this;
  220. }    
  221.  
  222. /* operator *= */
  223. inline complex & complex::operator *= ( const complex& z)
  224. {
  225.   *this = *this * z;
  226.   return  *this;
  227. }
  228. inline complex & complex::operator *= ( double x )
  229. {
  230.   re *= x;
  231.   im *= x;
  232.   return  *this;
  233. }
  234.  
  235. inline complex & complex::operator /= ( const complex& z)
  236. {
  237.   *this = *this / z;
  238.   return  *this;
  239. }    
  240. inline complex & complex::operator /= ( double x)
  241. {
  242.   re /= x;
  243.   im /= x;
  244.   return  *this;
  245. }    
  246.  
  247. inline complex & complex::operator += ( const complex& z)
  248. {
  249.   re += z.re;
  250.   im += z.im;
  251.   return  *this;
  252. }
  253. inline complex & complex::operator += ( double x)
  254. {
  255.   re += x;
  256.   return  *this;
  257. }
  258.  
  259. inline complex & complex::operator -= ( const complex& z)
  260. {
  261.   re -= z.re;
  262.   im -= z.im;
  263.   return  *this;
  264. }
  265.  
  266. inline complex & complex::operator -= ( double x)
  267. {
  268.   re -= x;
  269.   return  *this;
  270. }    
  271.  
  272. /* operator && */
  273. inline int operator && ( const complex & lhs, const complex & rhs )
  274. {
  275.   return  (( lhs.re != 0 ) || ( lhs.im != 0 )) &&
  276.     (( rhs.re != 0 ) || ( rhs.im != 0 )) ;
  277. }    
  278. inline int operator && ( double lhs, const complex & rhs )
  279. {
  280.   return  ( lhs != 0 ) && (( rhs.re != 0 ) || ( rhs.im != 0 )) ;
  281. }    
  282. inline int operator && ( const complex & lhs, double rhs )
  283. {
  284.   return  (( lhs.re != 0 ) || ( lhs.im != 0 )) && ( rhs != 0 ) ;
  285. }    
  286.  
  287. /* operator || */
  288. inline int operator || ( const complex & lhs, const complex & rhs )
  289. {
  290.   return  (( lhs.re != 0 ) || ( lhs.im != 0 )) ||
  291.     (( rhs.re != 0 ) || ( rhs.im != 0 )) ;
  292. }
  293. inline int operator || ( double lhs, const complex & rhs )
  294. {
  295.   return  ( lhs != 0 ) || (( rhs.re != 0 ) || ( rhs.im != 0 )) ;
  296. }
  297. inline int operator || ( const complex & lhs, double rhs )
  298. {
  299.   return  (( lhs.re != 0 ) || ( lhs.im != 0 )) || ( rhs != 0 );
  300. }    
  301.  
  302. /* operator != */
  303. inline  int operator != ( const complex& lhs, const complex& rhs )
  304. {
  305.   return  ( lhs.re != rhs.re ) || ( lhs.im != rhs.im );
  306. }
  307. inline  int operator != ( double lhs, const complex& rhs )
  308. {
  309.   return  ( lhs != rhs.re ) || ( 0 != rhs.im );
  310. }
  311. inline  int operator != ( const complex& lhs, double rhs )
  312. {
  313.   return  ( lhs.re != rhs ) || ( lhs.im != 0 );
  314. }
  315.  
  316. /* operator == */
  317. inline  int operator == ( const complex& lhs, const complex& rhs )
  318. {
  319.   return  ( lhs.re == rhs.re ) && ( lhs.im == rhs.im );
  320. }
  321. inline  int operator == ( double lhs, const complex& rhs )
  322. {
  323.   return  ( lhs == rhs.re ) && ( 0 == rhs.im );
  324. }
  325. inline  int operator == ( const complex& lhs, double rhs )
  326. {
  327.   return  ( lhs.re == rhs ) && ( lhs.im == 0 );
  328. }
  329.  
  330. inline double arg( const complex& z)
  331. {
  332.   return atan2(z.im,z.re);
  333. }
  334.  
  335. inline complex atanh( const complex& z) 
  336. {
  337.   complex iz(-z.im, z.re);
  338.   complex ix = atan(iz);
  339.   return complex ( ix.im, -ix.re);
  340. }
  341.  
  342. inline complex asinh( const complex& z)
  343. {
  344.   complex iz(-z.im, z.re);
  345.   complex ix = asin(iz);
  346.   return complex ( ix.im, -ix.re);
  347. }
  348.  
  349. inline double norm( const complex& z)
  350. {
  351.   return z.re*z.re + z.im*z.im;
  352. }
  353.  
  354. inline double modulus( const complex& z)
  355. {
  356.   return abs(z);
  357. }
  358.  
  359. inline complex conj( const complex& z)
  360. {
  361.   return complex( z.re, -z.im );
  362. }
  363.  
  364. inline complex cos( const complex& z )
  365. {
  366.   return complex( cos(z.re) * cosh( z.im ),  -( sin( z.re) * sinh(z.im)));
  367. }
  368.  
  369. inline complex cosh( const complex& z )
  370. {
  371.   return complex ( cosh(z.re) * cos(z.im), sinh(z.re) * sin(z.im) );
  372. }
  373.  
  374. inline complex sin( const complex& z )
  375. {
  376.   return complex ( sin(z.re) * cosh(z.im), cos(z.re) * sinh(z.im) );
  377. }
  378.  
  379. inline complex sinh( const complex& z )
  380. {
  381.   return complex ( sinh(z.re) * cos(z.im), cosh(z.re) * sin(z.im) );
  382. }
  383.  
  384. inline complex tan( const complex& z )
  385. {
  386.   double x = 2*z.re;
  387.   double y = 2*z.im;
  388.   double t = 1.0/(cos(x) +cosh(y));
  389.   
  390.   return complex( t*sin(x), t*sinh(y) );
  391. }
  392.  
  393. inline complex tanh( const complex& z )
  394. {
  395.   double x = 2*z.re;
  396.   double y = 2*z.im;
  397.   double t = 1.0/(cosh(x) +cos(y));
  398.   
  399.   return complex( t*sinh(x), t*sin(y) );
  400. }    
  401.  
  402. inline complex exp( const complex& z )
  403. {
  404.   double x = exp(z.re);
  405.   return complex( x*cos(z.im), x*sin(z.im) );
  406. }    
  407.  
  408. inline complex log( const complex& z )
  409. {
  410.   return complex( log( abs(z) ), arg( z ) );
  411. }    
  412.  
  413. inline complex log10( const complex& z )
  414. {
  415.   return complex( 0.2171472409516259*log( norm(z) ), arg( z ) );
  416. }    
  417.  
  418. inline complex polar ( double r, double theta )
  419. {
  420.   return complex ( r * cos(theta), r * sin(theta));
  421. }
  422.  
  423. #endif
  424.  
  425.  
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.  
  434.